/// @tags: FFT
#include <algorithm>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <iostream>

namespace BlueQuantum {

int const N = 1 << 18;

template <typename T>
inline T &read(T &x) {
  x = 0;
  bool f = false;
  short ch = getchar();
  while (!isdigit(ch)) {
    if (ch == '-') f = true;
    ch = getchar();
  }
  while (isdigit(ch)) x = x * 10 + (ch ^ '0'), ch = getchar();
  if (f) x = -x;
  return x;
}

struct Complex {
  double real, imag;

  explicit Complex(double r = 0.0, double i = 0.0) : real(r), imag(i) {}

  inline Complex operator+(Complex const &rhs) const {
    return Complex(real + rhs.real, imag + rhs.imag);
  }

  inline Complex operator-(Complex const &rhs) const {
    return Complex(real - rhs.real, imag - rhs.imag);
  }

  inline Complex operator*(Complex const &rhs) const {
    return Complex(real * rhs.real - imag * rhs.imag, real * rhs.imag + imag * rhs.real);
  }
};

class Polynomial {
 private:
  Complex f[N];

 public:
  static int cvt[N];

  inline Complex &operator[](int index) { return f[index]; }

  inline void FFT(bool const typ, int maxl) {
    for (int i = 1; i < maxl; ++i)
      if (i < cvt[i]) std::swap(f[i], f[cvt[i]]);
    for (int i = 2; i <= maxl; i <<= 1) {
      int mid = i >> 1;
      Complex wn(cos(2.0 * M_PI / i), typ ? sin(2.0 * M_PI / i) : -sin(2 * M_PI / i));
      for (int j = 0; j < maxl; j += i) {
        Complex w(1, 0);
        for (int k = 0; k < mid; ++k, w = w * wn) {
          Complex tmp = f[j + k + mid] * w;
          f[j + k + mid] = f[j + k] - tmp;
          f[j + k] = f[j + k] + tmp;
        }
      }
    }
  }
  inline void fft(bool opt, int maxl) {
    for (int i = 0; i < maxl; ++i)
      if (i < cvt[i]) std::swap(f[i], f[cvt[i]]);
    for (int j = 2; j <= maxl; j <<= 1) {
      int mid = j >> 1;
      Complex wn(cos(2.0 * M_PI / j), opt ? sin(2.0 * M_PI / j) : -sin(2.0 * M_PI / j));
      for (int k = 0; k < maxl; k = k + j) {
        Complex w(1, 0);
        for (int h = 0; h < mid; ++h, w = w * wn) {
          Complex tmp = f[k + h];
          f[k + h] = f[k + h] + w * f[k + h + mid];
          f[k + h + mid] = tmp - w * f[k + h + mid];
        }
      }
    }
  }
} Q, _Q, G;

int n;
int Polynomial::cvt[N];

inline int main() {
  read(n);
  for (int i = 1; i <= n; ++i)
    scanf("%lf", &Q[i].real), _Q[n - i + 1] = Q[i], G[i].real = 1.0 / i / i;
  int maxl = 1, l = 0;
  while (maxl < n + n) maxl <<= 1, ++l;
  for (int i = 1; i < maxl; ++i)
    Polynomial::cvt[i] = Polynomial::cvt[i >> 1] >> 1 | ((i & 1) << (l - 1));
  Q.FFT(true, maxl), _Q.FFT(true, maxl), G.FFT(true, maxl);
  for (int i = 0; i < maxl; ++i) Q[i] = Q[i] * G[i];
  for (int i = 0; i < maxl; ++i) _Q[i] = _Q[i] * G[i];
  Q.FFT(false, maxl), _Q.FFT(false, maxl);
  for (int i = 0; i < maxl; ++i) _Q[i].real /= maxl, Q[i].real /= maxl;
  for (int i = 1; i <= n; ++i) printf("%.3lf\n", Q[i].real - _Q[n - i + 1].real);
  return 0;
}

}  // namespace BlueQuantum

int main() {
#ifndef ONLINE_JUDGE
#ifdef LOCAL
  freopen("/tmp/CodeTmp/testdata.in", "r", stdin);
  freopen("/tmp/CodeTmp/testdata.out", "w", stdout);
#else
  freopen("P3338 [ZJOI2014]力.in", "r", stdin);
  freopen("P3338 [ZJOI2014]力.out", "w", stdout);
#endif
#endif

  return BlueQuantum::main();
}